package com.company.loganalyzer.tools;

import com.company.loganalyzer.dto.ToolInput;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 工具注册中心
 * 
 * 管理所有可用的日志分析工具，提供工具发现和选择功能
 * 对应Python版本中工具函数的管理机制
 */
@Component
@Slf4j
@RequiredArgsConstructor
public class ToolRegistry {

    private final List<LogAnalysisTool> tools;
    private Map<String, LogAnalysisTool> toolMap;
    private List<LogAnalysisTool> sortedTools;

    @PostConstruct
    public void init() {
        // 构建工具映射
        toolMap = tools.stream()
            .collect(Collectors.toMap(
                LogAnalysisTool::getName,
                tool -> tool,
                (existing, replacement) -> {
                    log.warn("发现重复的工具名称: {}, 使用第一个工具", existing.getName());
                    return existing;
                }
            ));

        // 按优先级排序工具
        sortedTools = tools.stream()
            .sorted(Comparator.comparingInt(LogAnalysisTool::getPriority))
            .collect(Collectors.toList());

        log.info("工具注册完成，共注册{}个工具: {}", 
            tools.size(), 
            tools.stream().map(LogAnalysisTool::getName).collect(Collectors.joining(", ")));
    }

    /**
     * 根据名称获取工具
     */
    public Optional<LogAnalysisTool> getTool(String name) {
        return Optional.ofNullable(toolMap.get(name));
    }

    /**
     * 获取所有可用工具
     */
    public List<LogAnalysisTool> getAllTools() {
        return new ArrayList<>(sortedTools);
    }

    /**
     * 根据输入自动选择最合适的工具
     */
    public List<LogAnalysisTool> selectTools(ToolInput input) {
        List<LogAnalysisTool> selectedTools = new ArrayList<>();

        // 根据优先级和能力匹配选择工具
        for (LogAnalysisTool tool : sortedTools) {
            if (tool.canHandle(input)) {
                selectedTools.add(tool);
                log.debug("选中工具: {} (优先级: {})", tool.getName(), tool.getPriority());
            }
        }

        // 如果没有工具能处理，返回默认的搜索工具
        if (selectedTools.isEmpty()) {
            Optional<LogAnalysisTool> searchTool = getTool("search_logs");
            if (searchTool.isPresent()) {
                selectedTools.add(searchTool.get());
                log.info("未找到匹配工具，使用默认搜索工具");
            }
        }

        log.info("为输入选择了{}个工具: {}", 
            selectedTools.size(),
            selectedTools.stream().map(LogAnalysisTool::getName).collect(Collectors.joining(", ")));

        return selectedTools;
    }

    /**
     * 根据查询内容智能选择单个最佳工具
     */
    public Optional<LogAnalysisTool> selectBestTool(ToolInput input) {
        List<LogAnalysisTool> candidates = selectTools(input);
        
        if (candidates.isEmpty()) {
            return Optional.empty();
        }

        // 如果有多个候选工具，选择优先级最高的
        return candidates.stream()
            .min(Comparator.comparingInt(LogAnalysisTool::getPriority));
    }

    /**
     * 根据查询关键词智能选择工具
     */
    public Optional<LogAnalysisTool> selectToolByQuery(String query) {
        if (query == null || query.trim().isEmpty()) {
            return getTool("search_logs");
        }

        String lowerQuery = query.toLowerCase();

        // 关键词匹配规则
        if (lowerQuery.contains("错误") || lowerQuery.contains("异常") || 
            lowerQuery.contains("error") || lowerQuery.contains("exception") ||
            lowerQuery.contains("分析错误") || lowerQuery.contains("analyze error")) {
            return getTool("analyze_errors");
        }

        if (lowerQuery.contains("统计") || lowerQuery.contains("分布") || 
            lowerQuery.contains("statistics") || lowerQuery.contains("count") ||
            lowerQuery.contains("数量")) {
            return getTool("get_log_statistics");
        }

        if (lowerQuery.contains("追踪") || lowerQuery.contains("trace") || 
            lowerQuery.contains("链路") || lowerQuery.contains("上下文") ||
            lowerQuery.contains("traceid")) {
            return getTool("trace_error_context");
        }

        // 默认使用搜索工具
        return getTool("search_logs");
    }

    /**
     * 获取工具信息列表
     */
    public List<Map<String, Object>> getToolInfoList() {
        return tools.stream()
            .map(tool -> {
                Map<String, Object> info = new HashMap<>();
                info.put("name", tool.getName());
                info.put("description", tool.getDescription());
                info.put("supportedParameters", Arrays.asList(tool.getSupportedParameters()));
                info.put("priority", tool.getPriority());
                info.put("timeoutSeconds", tool.getTimeoutSeconds());
                return info;
            })
            .collect(Collectors.toList());
    }

    /**
     * 获取工具使用建议
     */
    public Map<String, String> getToolUsageSuggestions() {
        Map<String, String> suggestions = new HashMap<>();
        
        suggestions.put("search_logs", "用于搜索和过滤日志，支持关键词、时间范围、服务名等条件");
        suggestions.put("analyze_errors", "用于分析错误日志的模式和趋势，识别根本原因");
        suggestions.put("get_log_statistics", "用于获取日志的统计信息和分布情况");
        suggestions.put("trace_error_context", "用于通过traceId追踪完整的请求链路和错误上下文");
        
        return suggestions;
    }

    /**
     * 验证工具配置
     */
    public Map<String, Boolean> validateTools() {
        Map<String, Boolean> validation = new HashMap<>();
        
        for (LogAnalysisTool tool : tools) {
            try {
                // 基本验证
                boolean isValid = tool.getName() != null && !tool.getName().trim().isEmpty() &&
                                tool.getDescription() != null && !tool.getDescription().trim().isEmpty() &&
                                tool.getSupportedParameters() != null;
                
                validation.put(tool.getName(), isValid);
                
                if (!isValid) {
                    log.warn("工具配置验证失败: {}", tool.getName());
                }
            } catch (Exception e) {
                log.error("工具验证异常: {}", tool.getName(), e);
                validation.put(tool.getName(), false);
            }
        }
        
        return validation;
    }

    /**
     * 获取工具统计信息
     */
    public Map<String, Object> getRegistryStatistics() {
        Map<String, Object> stats = new HashMap<>();
        
        stats.put("totalTools", tools.size());
        stats.put("toolNames", tools.stream().map(LogAnalysisTool::getName).collect(Collectors.toList()));
        
        // 按优先级分组
        Map<Integer, Long> priorityGroups = tools.stream()
            .collect(Collectors.groupingBy(LogAnalysisTool::getPriority, Collectors.counting()));
        stats.put("priorityDistribution", priorityGroups);
        
        // 工具验证状态
        Map<String, Boolean> validation = validateTools();
        long validTools = validation.values().stream().mapToLong(valid -> valid ? 1 : 0).sum();
        stats.put("validTools", validTools);
        stats.put("invalidTools", tools.size() - validTools);
        
        return stats;
    }
}